package com.wanshi.controller;

import com.wanshi.po.Record;
import com.wanshi.po.Result;
import com.wanshi.service.RecordService;
import com.wanshi.utils.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;
import java.util.UUID;

@SuppressWarnings("all")
@Controller
@RequestMapping("dati")
public class DatiPrintController {



    @Autowired
    private RecordService recordService;

    private static String lineSeparator = System.getProperty("line.separator", "\n");


    @RequestMapping(value="/test6")
    @ResponseBody
    public Result test6(HttpSession session, int id, String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals("153"+lineSeparator +
                    "370"+lineSeparator +
                    "371"+lineSeparator +
                    "407"+lineSeparator);
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    private String jiujiu() {
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= 9; x++) {
            for (int y = 1; y <= x; y++) {
                buffer.append(y + "*" + x + "=" + x * y + "\t");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test10")
    @ResponseBody
    public Result test10(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals(jiujiu());
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String printZhiShu(){
        StringBuffer buffer = new StringBuffer();
        for(int x =2;x<100;x++){
            boolean flag = true;
            for (int i = 2; i <x; i++) {
                //用x取余遍历到的每一个数  i
                if(x % i == 0){
                    flag = false;
                }
            }
            if(flag){
                buffer.append(x);
                buffer.append(""+lineSeparator);
            }
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test18")
    @ResponseBody
    public Result test18(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals(printZhiShu());
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public static String printRect(int x,int y){
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                buffer.append("*");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test19")
    @ResponseBody
    public Result test19(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 3;
            int y = 6;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x,y});
            flag = result.equals(printRect(3,6));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }


    public static String printKRect(int x,int y){
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                if(i==0){
                    buffer.append("*");
                }else if(i == x-1){
                    buffer.append("*");
                }else{
                    if(j==0 || j==y-1){
                        buffer.append("*");
                    }else{
                        buffer.append(" ");
                    }
                }

            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }


    @RequestMapping(value="/test20")
    @ResponseBody
    public Result test20(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 6;
            int y = 10;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x,y});
            flag = result.equals(printKRect(6,10));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    @RequestMapping(value="/test36")
    @ResponseBody
    public Result test36(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 6;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals("0,1,1,2,3,5");
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 8;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals("0,1,1,2,3,5,8,13");
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String zheng(int n){
        StringBuffer buffer = new StringBuffer();
        for (int x = 0; x < n; x++) {
            for (int y = 0; y <x+1; y++) {
                buffer.append("*");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test37")
    @ResponseBody
    public Result test37(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(zheng(x));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(zheng(x));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }


    public String dao(int n){
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <=n; x++) {
            for (int y = 1; y <= n+1-x; y++) {
                buffer.append("*");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test38")
    @ResponseBody
    public Result test38(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(dao(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(dao(4));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String lingxing(int n) {
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= n; x++) {
            for (int y = 0; y < n - x; y++) {
                buffer.append(" ");
            }
            for (int y = 0; y < n; y++) {
                buffer.append("*");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test39")
    @ResponseBody
    public Result test39(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(lingxing(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(lingxing(4));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String sanjiao(int n){
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= n; x++) {
            for (int y = 0; y < n - x; y++) {
                buffer.append(" ");
            }
            for (int y = 0; y < x; y++) {
                buffer.append("* ");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test40")
    @ResponseBody
    public Result test40(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(sanjiao(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(sanjiao(4));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String printNum(int n) {
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= n; x++) {
            for (int y = 1; y <= x; y++) {
                buffer.append(y);
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test43")
    @ResponseBody
    public Result test43(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printNum(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printNum(4));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String printZimu(int n) {
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= n; x++) {
            for (int y = 65; y <= 64+x; y++) {
                buffer.append( (char)y);
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();

    }

    @RequestMapping(value="/test44")
    @ResponseBody
    public Result test44(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printZimu(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 4;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printZimu(4));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String cc(int n) {
        StringBuffer buffer = new StringBuffer();
        for (int x = 1; x <= n; x++) {
            for (int y = 64+n; y > 64+n-x; y--) {
                buffer.append((char)y);
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }
    @RequestMapping(value="/test45")
    @ResponseBody
    public Result test45(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 3;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(cc(3));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 5;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(cc(5));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }
    public String abc(int n){
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n-1-i; j++) {
                buffer.append(" ");
            }
            for (int x = 64+n-i; x <=64+n; x++) {
                buffer.append((char)x);
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test46")
    @ResponseBody
    public Result test46(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(abc(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 7;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(abc(7));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }
    @RequestMapping(value="/test55")
    @ResponseBody
    public Result test55(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals("冬季");
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 7;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals("夏季");
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }
    @RequestMapping(value="/test58")
    @ResponseBody
    public Result test58(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals("2025"+lineSeparator +
                    "3025"+lineSeparator +
                    "9801"+lineSeparator);

        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }
    public String da36() {
        StringBuffer buffer = new StringBuffer();
        for (int x = 10; x < 100; x++) {
            int ge = x % 10;
            int shi = x / 10;
            int y = ge * 10 + shi;
            if (y - x == 36) {
                buffer.append(x+""+lineSeparator);
            }
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test59")
    @ResponseBody
    public Result test59(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals(da36());

        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String printOushu(){
        int  x = 1;
        int count = 0;
        StringBuffer buffer = new StringBuffer();
        while(x <= 100){
            if(x % 2==0){
                count++;
                if(count % 5 == 0){
                    buffer.append(x+""+lineSeparator);
                }else{
                    buffer.append(x+",");
                }
            }
            x++;
        }
        return buffer.toString();
    }
    @RequestMapping(value="/test60")
    @ResponseBody
    public Result test60(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            
            String result = daTiUtils.writeContent2(uuid,content,method,null);
            flag = result.equals(printOushu());

        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public String printSanjiao(int n){
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < n; i++) {

            for (int j = 0; j < n-1-i; j++) {
                buffer.append(" ");
            }
            for (int j = 1; j <= 2*i+1; j++) {
                buffer.append("*");
            }
            buffer.append(""+lineSeparator);
        }
        return buffer.toString();
    }
    @RequestMapping(value="/test63")
    @ResponseBody
    public Result test63(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 2;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printSanjiao(2));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 1;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(printSanjiao(1));

        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

    public static String fenjie(int num){
        StringBuffer buffer = new StringBuffer();
        for(int x = 2;x<=num;x++){
            if(num % x == 0){
                buffer.append(x+""+lineSeparator);
                num = num / x;
                x=1;
            }
        }
        return buffer.toString();
    }

    @RequestMapping(value="/test71")
    @ResponseBody
    public Result test71(HttpSession session,int id,String content, String method) {
        if (TextUtil.kong(content)) return new Result(Constants.ERROR);
        Record record = RequestUtils.getRecord(session, id, content);
        DaTiUtils daTiUtils = new DaTiUtils<>();
        boolean flag = true;
       String uuid = UUID.randomUUID().toString().replace("-", "");
        try {
            int x = 50;
            
            String result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(fenjie(50));
            if(!flag){
                return RequestUtils.getResult(recordService,record, flag);
            }
            x = 10;
            result = daTiUtils.writeContent2(uuid,content,method,new Object[]{x});
            flag = result.equals(fenjie(10));
        } catch (Exception e) {
            flag = false;
        }finally {
            ThreadPoolUtils.pool.execute(new AsynOprDatabaseUtil(recordService, record, flag,uuid));
            return RequestUtils.getResult(recordService, record, flag);
        }
    }

}
